package com.anan;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Painter
 * @project_name: aircraft-war
 * @system_login: sunshine
 * @time: 2023/11/520:17
 */



public class GamePanel extends JPanel {


    public List<Background> backgroundList = new ArrayList<>();  // 背景数组列表

    public List<SmallEnemy> smallEnemyList = new ArrayList<>();  // 小型敌机数组列表

    public List<MidEnemy> midEnemyList = new ArrayList<>();  // 中型敌机
    public List<BigEnemy> bigEnemyList = new ArrayList<>();  // 大型敌机

    public List<Bullet> playerBulletList = new ArrayList<>();  // 玩家子弹
    public List<Bomb> bombList = new ArrayList<>();  // 爆炸图片

    public Image[] supplies = {  // 补给图片数组
            Imagevalue.bullet_supply,  // 超级子弹补给
            Imagevalue.gain_life, // 玩家生命补给
            Imagevalue.bomb_supply};  // 全屏炸弹补给


    public Hero hero = new Hero(GameFrame.WIDTH/2-50, GameFrame.HEIGHT-200);  // 玩家飞机1
    public Hero hero1 = new Hero(GameFrame.WIDTH/2-50, GameFrame.HEIGHT-200, 2);  // 玩家飞机2

    public boolean start = false;  // 是否开始游戏
    public int fbs = 0; // 循环帧率
    public Timer timer;  // 主循环定时监视器
    public Timer timerSupply;  // 补给定时监视器
    public Timer timerbullet;  // 自动发射子弹定时监视器
    public Timer timerplayer;  // 自动发射子弹定时监视器
    public Supply supply;  // 补给
    public boolean superBullet = false;  // 是否获得超级子弹
    public int life = 5;  // 玩家生命
    public int bomb = 3;  // 全屏炸弹

    public int score = 0;  // 分数
    public boolean automatic = true;  // 是否自动发射子弹
    public boolean pause = false;  // 暂停
    public boolean Invincible = false;  // 玩家无敌状态

    public GamePanel() {

        this.setLayout(null);  // 设置布局管理为null（方便使用定位布局控件的位置）
        this.setFocusable(true);//获得焦点事件,为了设置键盘按键事件
        this.addKeyListener(new keylistener());  // 添加键盘监听器
        this.addMouseListener(new mouselistener());  // 添加鼠标点击监听器
        this.addMouseMotionListener(new mouselistener());  // 添加鼠标移动监听器
        timer = new Timer(10, new timing());  // 创建定时监听事件，每10毫秒执行一次
        timer.start();  // 启动监听事件
        timerSupply = new Timer(18 * 1000, new timingsupply());  // 创建发放补给监听事件，每18秒发放一次
        timerSupply.start();
        timerbullet = new Timer(200, new timingbullet());  // 创建自动发射子弹监听事件，每200毫秒添加以可子弹
        timerbullet.start();
        timerplayer = new Timer(5000,new timingplayer());  // 玩家无敌监听事件，死亡复活时5秒无敌
    }
    @Override
    public void paintComponent(Graphics g) {  // 绘制组件
        repaint();  // 更新绘制
        Graphics2D g2 = (Graphics2D) g;  // 转换绘制方式
        g2.setStroke(new BasicStroke(5));  // 设置画笔粗细
        // 绘制背景
        for (int i = 0; i < backgroundList.size(); i++) {
            Background background = backgroundList.get(i);
            g.drawImage(background.getImage(), background.getX(), background.getY(), this.getWidth(), this.getHeight(), null);
        }

        if (start&&!pause) {  // 如果游戏是开始状态和非暂停状态

            // 绘制大型敌机
            for (int i = 0; i < bigEnemyList.size(); i++) {
                BigEnemy bigEnemy = bigEnemyList.get(i);
                float num = bigEnemy.aliveValue / 5.0f;  // 血量百分比
                if (bigEnemy.aliveValue < 4) {  // 如果血量大于4
                    g2.setColor(new Color(255, 0, 0));  // 绘制红色
                } else {  // 绘制绿色
                    g2.setColor(new Color(0, 255, 0));
                }
                // 绘制血量
                g2.drawLine(bigEnemy.x, bigEnemy.y - 10, bigEnemy.x + Math.round(bigEnemy.image.getWidth(this) * num), bigEnemy.y - 10);
                // 绘制大型敌机动图
                if (fbs % 5 == 0) {
                    g.drawImage(bigEnemy.image, bigEnemy.x, bigEnemy.y, bigEnemy.image.getWidth(this), bigEnemy.image.getHeight(this), null);
                } else {
                    g.drawImage(bigEnemy.image1, bigEnemy.x, bigEnemy.y, bigEnemy.image1.getWidth(this), bigEnemy.image1.getHeight(this), null);
                }
            }

            // 绘制中型敌机
            for (int i = 0; i < midEnemyList.size(); i++) {
                MidEnemy midEnemy = midEnemyList.get(i);
                float num = midEnemy.aliveValue / 3.0f;
                if (midEnemy.aliveValue < 3) {
                    g2.setColor(new Color(255, 0, 0));
                } else {
                    g2.setColor(new Color(0, 255, 0));
                }
                g2.drawLine(midEnemy.x, midEnemy.y - 10, midEnemy.x + Math.round(midEnemy.image.getWidth(this) * num), midEnemy.y - 10);
                g.drawImage(midEnemy.image, midEnemy.x, midEnemy.y, midEnemy.image.getWidth(this), midEnemy.image.getHeight(this), null);
            }

            // 绘制小型敌机
            for (int i = 0; i < smallEnemyList.size(); i++) {
                SmallEnemy smallEnemy = smallEnemyList.get(i);
                g.drawImage(smallEnemy.image, smallEnemy.x, smallEnemy.y, smallEnemy.image.getWidth(this), smallEnemy.image.getHeight(this), null);
            }




            // 绘制玩家子弹

            for (int i = 0; i < playerBulletList.size(); i++) {
                Bullet bullet = playerBulletList.get(i);
                g.drawImage(bullet.getImage(), bullet.getX(), bullet.getY(), bullet.getImage().getWidth(this), bullet.getImage().getHeight(this), null);
            }

            // 绘制玩家飞机
            if (hero.getIslive()) {
                // 绘制玩家飞机动图
                if (fbs % 5 == 0) {
                    g.drawImage(hero.getImage(), hero.getX(), hero.getY(), hero.getImage().getWidth(this), hero.getImage().getHeight(this), null);
                } else {
                    g.drawImage(hero1.getImage(), hero1.getX(), hero1.getY(), hero1.getImage().getWidth(this), hero1.getImage().getHeight(this), null);
                }
            }
            // 绘制爆炸图片
            for (int i = 0; i < bombList.size(); i++) {  // 这里必须使用这种方法，防止数组为空
                Bomb bomb = bombList.get(i);  // 获取爆炸图片类对象
                if (bomb.type == 1) {  // 如果是小型敌机
                    g.drawImage(bomb.smallEnemyDestroy[bomb.index], bomb.x, bomb.y, bomb.smallEnemyDestroy[bomb.index].getWidth(this), bomb.smallEnemyDestroy[bomb.index].getHeight(this), null);
                } else if (bomb.type == 2) {  // 如果是中型敌机
                    g.drawImage(bomb.midEnemyDestroy[bomb.index], bomb.x, bomb.y, bomb.midEnemyDestroy[bomb.index].getWidth(this), bomb.midEnemyDestroy[bomb.index].getHeight(this), null);
                } else if (bomb.type == 3) {  // 如果是大型敌机
                    g.drawImage(bomb.bigEnemyDestroy[bomb.index], bomb.x, bomb.y, bomb.bigEnemyDestroy[bomb.index].getWidth(this), bomb.bigEnemyDestroy[bomb.index].getHeight(this), null);
                }
            }
            if (supply != null) {  // 如果补给对象不为空，绘制补给
                g.drawImage(supply.image, supply.x, supply.y, supply.image.getWidth(this), supply.image.getHeight(this), null);
            }

            // 绘制得分
            g.setColor(new Color(255, 0, 0));
            g.setFont(new Font("微软雅黑", Font.BOLD, 30));
            g.drawString("SCORE:" + score, 10, 40);

            // 绘制全屏爆炸数量
            g.drawImage(Imagevalue.bomb, 10, GameFrame.HEIGHT - 100, null);
            g.setColor(new Color(255, 255, 255));
            g.setFont(new Font("微软雅黑", Font.BOLD, 50));
            g.drawString("X" + bomb, 80, GameFrame.HEIGHT - 50);
            // 绘制玩家生命值，生命飞机数量
            for (int i = 0; i < life; i++) {
                g.drawImage(Imagevalue.life, GameFrame.WIDTH-60 - Imagevalue.life.getWidth(this) * i, GameFrame.HEIGHT - 100, null);
            }

        } else {  // 如果不是游戏开始状态，就绘制暂停状态
            if(pause){  // 如果是暂停状态
                g.drawImage(Imagevalue.pause,0,0,GameFrame.WIDTH,GameFrame.HEIGHT,null);
            }else {  // 绘制游戏初始状态
                g.drawImage(Imagevalue.again, GameFrame.WIDTH/2-150, 500, Imagevalue.again.getWidth(this), Imagevalue.again.getHeight(this), null);
                g.drawImage(Imagevalue.gameOver, GameFrame.WIDTH/2-150, 700, Imagevalue.gameOver.getWidth(this), Imagevalue.gameOver.getHeight(this), null);
            }
        }
    }

    public boolean isHit(SmallEnemy e, Bullet b) {  // 敌机与玩家子弹碰撞检测
        Rectangle erect = new Rectangle(e.x, e.y, e.image.getWidth(this), e.image.getHeight(this));
        Rectangle brect = new Rectangle(b.getX(), b.getY(), b.getImage().getWidth(this), b.getImage().getHeight(this));
        return erect.intersects(brect);
    }

    public boolean isHit(SmallEnemy e, Hero h) {  // 敌机与玩家碰撞检测
        Rectangle erect = new Rectangle(e.x, e.y, e.image.getWidth(this), e.image.getHeight(this));
        Rectangle hrect = new Rectangle(h.getX(), h.getY(), h.getImage().getWidth(this), h.getImage().getHeight(this));
        return erect.intersects(hrect);
    }

    public boolean isHit(Supply e, Hero h) {  // 补给与玩家碰撞检测
        Rectangle erect = new Rectangle(e.x, e.y, e.image.getWidth(this), e.image.getHeight(this));
        Rectangle hrect = new Rectangle(h.getX(), h.getY(), h.getImage().getWidth(this), h.getImage().getHeight(this));
        return erect.intersects(hrect);
    }

    class keylistener extends KeyAdapter {  // 键盘按键事件
        @Override
        public void keyPressed(KeyEvent e) {  // 键盘按下
            super.keyPressed(e);
            int speed = 20;  // 玩家飞机的移动速度
            int key = e.getKeyCode(); // 获取按下的按键编码
            switch (key) {
                case KeyEvent.VK_LEFT:  // 左
                    if (hero.getX() > 0) {
                        hero.setX(hero.getX() - speed);
                        hero1.setX(hero1.getX() - speed);
                    }
                    break;
                case KeyEvent.VK_UP:  // 上
                    if (hero.getY() > 0) {
                        hero.setY(hero.getY() - speed);
                        hero1.setY(hero1.getY() - speed);
                    }
                    break;
                case KeyEvent.VK_RIGHT:  // 右
                    if (hero.getX() < GameFrame.WIDTH - 116) {
                        hero.setX(hero.getX() + speed);
                        hero1.setX(hero1.getX() + speed);
                    }
                    break;
                case KeyEvent.VK_DOWN:  // 下
                    if (hero.getY() < GameFrame.HEIGHT - 200) {
                        hero.setY(hero.getY() + speed);
                        hero1.setY(hero1.getY() + speed);
                    }
                    break;

                case KeyEvent.VK_Z:  // z 键
                    pause = !pause;  // 切换暂停状态
                    break;
                case KeyEvent.VK_B:  // b 键
                    if(!automatic){  // 如果是手动发射子弹，将所右敌机坐标大于0 的属性型设置为false
                        if(bomb>0&&start) {
                            PlayerMusic.BombMusic();
                            for (SmallEnemy s : smallEnemyList) {
                                if (s.y > 0) {
                                    s.Isalive = false;
                                    score += 2000;
                                }
                            }
                            for (MidEnemy m : midEnemyList) {
                                if (m.y > 0) {
                                    m.Isalive = false;
                                    score += 5000;
                                }
                            }
                            for (BigEnemy b : bigEnemyList) {
                                if (b.y > 0) {
                                    b.Isalive = false;
                                    score += 10000;
                                }
                            }
                        }
                        bomb -= 1;  // 全屏炸弹数量减1
                        if(bomb<0) bomb=0;
                    }
            }

        }

        @Override
        public void keyReleased(KeyEvent e) {  // 键盘按下
            super.keyReleased(e);
            int speed = 20;  // 玩家飞机的移动速度
            int key = e.getKeyCode(); // 获取按下的按键编码
            if(key == KeyEvent.VK_SPACE) {  // 空格键
                    if(automatic){  // 如果是自动发射子弹，空格键为全屏炸弹
                        if(bomb>0&&start) {  // 如果全屏炸弹数量大于0和开始状态，将坐标大于0 的飞机的存活属性设置为false
                            PlayerMusic.BombMusic();
                            for (SmallEnemy s : smallEnemyList) {
                                if (s.y > 0) {
                                    s.Isalive = false;
                                    score += 2000;
                                }
                            }
                            for (MidEnemy m : midEnemyList) {
                                if (m.y > 0) {
                                    m.Isalive = false;
                                    score += 5000;
                                }
                            }
                            for (BigEnemy b : bigEnemyList) {
                                if (b.y > 0) {
                                    b.Isalive = false;
                                    score += 10000;
                                }
                            }
                        }
                        bomb -= 1;  // 全平炸弹数量减1
                        if(bomb<0) bomb=0;
                    }else {  // 如果子寿动改发射子弹，空格键为添加子弹
                        PlayerMusic.bulletmusic();
                        if (!superBullet) {  // 如果未获得超级子弹
                            if (playerBulletList.size() < 10) {  // 添加单发子弹
                                playerBulletList.add(new Bullet(hero.getX() + 50, hero.getY() + 20));
                            }
                        } else {  // 获得超级子弹
                            if (playerBulletList.size() < 20) {  // 添加双发子弹
                                playerBulletList.add(new Bullet(hero.getX() + 18, hero.getY() + 50, 2));
                                playerBulletList.add(new Bullet(hero.getX() + 80, hero.getY() + 50, 2));
                            }
                        }
                    }
            }

        }
    }

    class mouselistener extends MouseAdapter {  // 鼠标事件

        @Override
        public void mousePressed(MouseEvent e) {  // 鼠标按下
            super.mousePressed(e);
            int x = e.getX();  // 获取鼠标点击的坐标
            int y = e.getY();
            // 如果点击重新开始的图片
            if (x > GameFrame.WIDTH/2-150 && x < GameFrame.WIDTH/2+150 && y > 500 && y < 540&&!pause) {  // 判断是不是在范围内点击
                start = true;  // 修改游戏开始状态
                // 清空所有敌机，爆炸图片，玩家子弹数组
                playerBulletList.removeAll(playerBulletList);
                smallEnemyList.removeAll(smallEnemyList);
                midEnemyList.removeAll(midEnemyList);
                bigEnemyList.removeAll(bigEnemyList);
                bombList.removeAll(bombList);
                // 重置玩家坐标
                hero.setX(GameFrame.WIDTH/2-50);
                hero1.setX(GameFrame.WIDTH/2-50);
                hero.setY(800);
                hero1.setY(800);
                life = 5;  // 重置生命值
                bomb = 3;  // 重置爆炸数量
                score = 0; // 重置分数
                // 如果点击退出游戏
            } else if (x > GameFrame.WIDTH/2-150 && x < GameFrame.WIDTH/2+150 && y > 700 && y < 740&&!pause) {  // 判断是不是在范围内点击
                int val = JOptionPane.showConfirmDialog(null, "是否退出游戏", "提示", JOptionPane.YES_NO_CANCEL_OPTION);
                if (val == 0) {
                    System.exit(0);
                }
            }
        }

        @Override
        public void mouseMoved(MouseEvent e) {   // 鼠标移动
            super.mouseMoved(e);
            // 如果鼠标移动在范围内，就将鼠标的坐标赋值给玩家飞机
            if (e.getX() > 51 && e.getX() < GameFrame.WIDTH - 51 && e.getY() > 63 && e.getY() < GameFrame.HEIGHT - 63) {
                hero.setX(e.getX() - 51);
                hero1.setX(e.getX() - 51);
                hero.setY(e.getY() - 63);
                hero1.setY(e.getY() - 63);
            }
        }
    }

    class timing implements ActionListener {  // 定时监听事件，按照规定的时间，到时间就调用(执行)一次
        public timing() {  // 创建构造方法，让创建对象时就创建一个背景，而不是在启动监听事件时再创建背景
            backgroundList.add(new Background(0, 0));  // 创建第一个背景图片
        }

        @Override
        public void actionPerformed(ActionEvent e) {  // 执行的动作
            fbs++;  // 自增1
            if (fbs > 100) fbs = 0;
            if (start&&!pause) {  // 如果是开始游戏状态
                if (backgroundList.size() == 1) {  // 如果背景数组列表等于1
                    backgroundList.add(new Background(0, -(GameFrame.HEIGHT-50)));  // 向数组列表中添加一个背景
                }

                // 移动背景
                for (int i = 0; i < backgroundList.size(); i++) {
                    Background background = backgroundList.get(i);
                    background.move();
                    if (background.getY() > GameFrame.HEIGHT-50) backgroundList.remove(background);  // 如果背景的y坐标大于950，就将这个背景从数组中删除
                }

                // 添加敌机
                if (fbs % 50 == 0) {
                    if (smallEnemyList.size() < 10) {  // 如果小型敌机小于10是添加小型敌机
                        smallEnemyList.add(new SmallEnemy());
                    } else if (midEnemyList.size() < 5) {
                        midEnemyList.add(new MidEnemy());
                    } else if (bigEnemyList.size() < 3) {
                        bigEnemyList.add(new BigEnemy());
                    }

                }

                // 移动小型敌机
                for (int i = 0; i < smallEnemyList.size(); i++) {
                    SmallEnemy smallEnemy = smallEnemyList.get(i);
                    if (isHit(smallEnemy, hero)&&!Invincible) {  // 如果玩家和敌机碰撞，判断玩家是否不是无敌状态
                        timerplayer.start();  // 启动玩家无敌状态
                        Invincible = true;  // 修改属性为true
                        life -= 1;  // 生命值减1
                        if(life==0){  // 如果生命值等于0时
                            start = false;  // 修改游戏开始状态属性为false，游戏结束
                        }
                        smallEnemy.Isalive = false;
                    }
                    if (!smallEnemy.Isalive) {
                        bombList.add(new Bomb(smallEnemy.x, smallEnemy.y, 1));
                        smallEnemyList.remove(smallEnemy);
                    } else {
                        smallEnemy.move();
                    }
                }
                // 移动中型敌机
                for (int i = 0; i < midEnemyList.size(); i++) {
                    MidEnemy midEnemy = midEnemyList.get(i);
                    if (isHit(midEnemy, hero)&&!Invincible) {
                        timerplayer.start();
                        Invincible = true;
                        life -= 1;
                        if(life==0){
                            start = false;
                        }
                        midEnemy.Isalive = false;
                    }
                    if (!midEnemy.Isalive) {
                        bombList.add(new Bomb(midEnemy.x, midEnemy.y, 2));
                        midEnemyList.remove(midEnemy);
                    } else {
                        midEnemy.move();
                    }
                }
                // 移动大型敌机
                for (int i = 0; i < bigEnemyList.size(); i++) {
                    BigEnemy bigEnemy = bigEnemyList.get(i);
                    if (isHit(bigEnemy, hero)&&!Invincible) {
                        timerplayer.start();
                        Invincible = true;
                        life -= 1;
                        if(life==0){
                            start = false;
                        }
                        bigEnemy.Isalive = false;
                    }
                    if (!bigEnemy.Isalive) {
                        bombList.add(new Bomb(bigEnemy.x, bigEnemy.y, 3));
                        bigEnemyList.remove(bigEnemy);
                    } else {
                        bigEnemy.move();
                    }
                }
                // 移动玩家子弹
                if (playerBulletList.size() > 0) {
                    for (int i = 0; i < playerBulletList.size(); i++) {
                        Bullet bullet = playerBulletList.get(i);


                        for (int j = 0; j < smallEnemyList.size(); j++) {// 判断敌机是否被玩家击中
                            SmallEnemy smallEnemy = smallEnemyList.get(j);
                            if (isHit(smallEnemy, bullet)) {
                                smallEnemy.aliveValue -= 1;
                                bullet.setIsalive(false);
                                if (smallEnemy.aliveValue == 0) {
                                    score += 2000;
                                    PlayerMusic.smallBombMusic();
                                    smallEnemy.Isalive = false;
                                }
                            }
                        }

                        for (int j = 0; j < midEnemyList.size(); j++) { // 判断敌机是否被玩家击中
                            MidEnemy enemy = midEnemyList.get(j);
                            if (isHit(enemy, bullet)) {
                                enemy.aliveValue -= 1;
                                bullet.setIsalive(false);
                                if (enemy.aliveValue == 0) {
                                    score += 5000;
                                    PlayerMusic.midBombMusic();
                                    enemy.Isalive = false;

                                }
                            }
                        }
                        for (int j = 0; j < bigEnemyList.size(); j++) {  // 判断敌机是否被玩家击中
                            BigEnemy enemy = bigEnemyList.get(j);
                            if (isHit(enemy, bullet)) {
                                enemy.aliveValue -= 1;
                                bullet.setIsalive(false);
                                if (enemy.aliveValue == 0) {
                                    score += 10000;
                                    PlayerMusic.bigBombMusic();
                                    enemy.Isalive = false;
                                }
                            }
                        }
                        if (!bullet.getIsalive()) {  // 如果子弹的存货状态为false就删除这个子弹
                            playerBulletList.remove(bullet);
                        } else {  // 如果子弹的存活状态为true就移动这颗子弹
                            bullet.move();  // 移动子弹
                        }
                    }
                }
                // 增加爆炸图片播放效果
                for (int i = 0; i < bombList.size(); i++) {
                    Bomb bomb = bombList.get(i);  //获取爆炸图片对象
                    if (bomb.type == 1) {  // 如果是小型敌机
                        if (fbs % 8 == 0) {  // 如果帧率求余8等于0时，延迟播放图片
                            bomb.index += 1;  // 播放图片的索引加1
                            if (bomb.index == 3) {  // 如果索引为3时，就删除这个爆炸图片对象
                                bombList.remove(bomb);
                            }
                        }
                    } else if (bomb.type == 2) {  // 中型敌机
                        if (fbs % 8 == 0) {
                            bomb.index += 1;
                            if (bomb.index == 3) {
                                bombList.remove(bomb);
                            }
                        }
                    } else if (bomb.type == 3) {  // 大型敌机
                        if (fbs % 8 == 0) {
                            bomb.index += 1;
                            if (bomb.index == 5) {
                                bombList.remove(bomb);
                            }
                        }
                    }
                }
                // 移动补给
                if (supply != null) {  // 如果补给对象不为空,并且存活
                    supply.move();
                    if (isHit(supply, hero)) {  // 判断玩家是否碰撞补给，获得
                        PlayerMusic.supplyBombMusic();
                        if (supply.type == 0) {  // 超级子弹补给
                            superBullet = true;
                            supply = null;
                        } else if (supply.type == 1) {  // 玩家生命补给
                            life += 1;
                            supply = null;
                        } else if (supply.type == 2) {  // 全屏炸弹补给
                            bomb += 1;
                            supply = null;
                        }
                    }
                }
            }
        }
    }

    class timingsupply implements ActionListener {  // 发放补给监听动作事件

        @Override
        public void actionPerformed(ActionEvent e) {
            int value = random.randint(0, 2);
            superBullet = false;  // 将超级子弹的属性值设置为false，没有获得
            supply = new Supply(supplies[value], value);  // 创建一个随机补给
        }
    }

    class timingbullet implements ActionListener {   // 自动发射子弹监听动作事件

        @Override
        public void actionPerformed(ActionEvent e) {
            if (automatic&&start&&!pause) {  // 如果是自动发射状态，开始状态，非暂停状态
                PlayerMusic.bulletmusic();
                if (!superBullet) {  // 如果未获得超级子弹
                    if (playerBulletList.size() < 10) {  // 添加单发子弹
                        playerBulletList.add(new Bullet(hero.getX() + 50, hero.getY() + 20));
                    }
                } else {  // 获得超级子弹
                    if (playerBulletList.size() < 20) {  // 添加双发子弹
                        playerBulletList.add(new Bullet(hero.getX() + 18, hero.getY() + 50, 2));
                        playerBulletList.add(new Bullet(hero.getX() + 80, hero.getY() + 50, 2));
                    }
                }
            }
        }
    }
    class timingplayer implements ActionListener {  // 玩家无敌监听动作事件

        @Override
        public void actionPerformed(ActionEvent e) {
            Invincible = false;  // 修改属性不是无敌状态
            timerplayer.stop();  // 停止事件监听
        }
    }
}

